home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 27 / CU Amiga Magazine's Super CD-ROM 27 (1998)(EMAP Images)(GB)[!][issue 1998-10].iso / CUCD / Programming / FreshBar / Source / WindowList.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-05-29  |  22.6 KB  |  969 lines
  1. //*************************************************************************//
  2. // Filename:    WindowList.cpp
  3. // Autor:       Christian Taulien of Strange Intelligence
  4. // Purpose:     Window management implementation for FreshBar
  5. // Creation:    17. Mai 1998
  6. //*************************************************************************//
  7.  
  8. #include <exec/types.h>
  9. #include <exec/nodes.h>
  10. #include <exec/lists.h>
  11. #include <exec/ports.h>
  12. #include <intuition/intuition.h>
  13. #include <libraries/gadtools.h>
  14.  
  15. #include <clib/exec_protos.h>
  16. #include <clib/intuition_protos.h>
  17. #include <clib/gadtools_protos.h>
  18. #include <clib/graphics_protos.h>
  19. #include <clib/utility_protos.h>
  20. #include <clib/dos_protos.h>
  21.  
  22. #include "WindowList.h"
  23. #include "VisualInfo.h"
  24. #include "TextMeasure.h"
  25. #include "global.h"
  26.  
  27. extern "C" void NewList(struct List *list);
  28.  
  29. void StripIntuiMessages(struct MsgPort *arg_poMsgPort, struct Window *arg_poWindow)
  30. /*S*/
  31. /*S*/ /* Methoden-Rahmen */
  32. /*************************************************************************
  33. * Name der Methode: ::StripIntuiMessages()
  34. *
  35. * Klasse: --
  36. *
  37. * Funktion:
  38. *   function to remove and reply all IntuiMessages on a port that have been
  39. *   sent to a particular window (note that we don't rely on the ln_Succ
  40. *   pointer of a message after we have replied it)
  41. *
  42. * Zugriff: public
  43. *
  44. * Eingabe-Parameter: 2
  45. *   arg_poMsgPort:  Zeiger auf den Messageport (UserPort) des Fensters
  46. *   arg_poWindow:   Zeiger auf das Fenster um das es dabei geht.
  47. *
  48. * Ausgabe-Parameter: -
  49. *
  50. * Aufgerufen von: -
  51. *
  52. * Verwendung folgender globaler Variablen/Strukturen: -
  53. *
  54. * Benutzte Methoden: 2
  55. *   exec.library/Remove()
  56. *   exec.library/ReplyMsg()
  57. *
  58. * Version: 1.0
  59. *
  60. * Autor: RKRM Libraries
  61. *
  62. * Datum: 17. Mai 1998
  63. *
  64. * Letzte Änderungen/Neuerungen:
  65. * 17. Mai 1998: Methode definiert
  66. *
  67. *************************************************************************/
  68. /*E*/
  69. {
  70.   struct IntuiMessage *poMsg = (struct IntuiMessage *)arg_poMsgPort->mp_MsgList.lh_Head;
  71.  
  72.   struct Node *succ;
  73.   while (succ = poMsg->ExecMessage.mn_Node.ln_Succ)
  74.   {
  75.     if (poMsg->IDCMPWindow == arg_poWindow)
  76.     {
  77.       // Intuition is about to free this message.
  78.       // Make sure that we have politely sent it back.
  79.       Remove((struct Node *) poMsg);
  80.  
  81.       ReplyMsg((struct Message *) poMsg);
  82.     } // if
  83.     poMsg = (struct IntuiMessage *) succ;
  84.   } // while
  85. } // StripIntuiMessages()
  86. /*E*/
  87. void CloseWindowSafely(struct Window *arg_poWindow)
  88. /*S*/
  89. /*S*/ /* Methoden-Rahmen */
  90. /*************************************************************************
  91. * Name der Methode: ::CloseWindowSafely()
  92. *
  93. * Klasse: --
  94. *
  95. * Funktion:
  96. *   Strip all IntuiMessages from an IDCMP which are waiting for a specific
  97. *   window.  When the messages are gone, set the UserPort of the window to
  98. *   NULL and call ModifyIDCMP(win,0).  This will free the Intuition arts
  99. *   of the IDMCMP and trun off message to this port without changing the
  100. *   original UserPort (which may be in use by other windows).
  101. *
  102. * Zugriff: public
  103. *
  104. * Eingabe-Parameter: 1
  105. *   arg_poWindow: Zeiger auf das Fenster
  106. *
  107. * Ausgabe-Parameter:
  108. *
  109. * Aufgerufen von:
  110. *
  111. * Verwendung folgender globaler Variablen/Strukturen:
  112. *
  113. * Benutzte Methoden: 5
  114. *   exec.library/Forbid()
  115. *   exec.library/Permit()
  116. *   intuition.library/ModifyIDCMP()
  117. *   intuition.library/CloseWindow()
  118. *   StripIntuiMessages()
  119. *
  120. * Version: 1.0
  121. *
  122. * Autor: RKRM Libraries
  123. *
  124. * Datum: 17. Mai 1998
  125. *
  126. * Letzte Änderungen/Neuerungen:
  127. * 17. Mai 1998: Methode definiert / RKRM-Libraries
  128. *
  129. *************************************************************************/
  130. /*E*/
  131. {
  132.   TRACE("Entry");
  133.   // if no valid window-pointer
  134.   if (!arg_poWindow)
  135.   {
  136.     return;
  137.   } // if
  138.  
  139.   // we forbid here to keep out of race conditions with Intuition
  140.   Forbid();
  141.  
  142.   // send back any messages for this window  that have not yet been processed
  143.   StripIntuiMessages(arg_poWindow->UserPort, arg_poWindow);
  144.  
  145.   // clear UserPort so Intuition will not free it
  146.   arg_poWindow->UserPort = NULL;
  147.  
  148.   // tell Intuition to stop sending more messages
  149.   ModifyIDCMP(arg_poWindow, 0L);
  150.  
  151.   // turn multitasking back on
  152.   Permit();
  153.  
  154.   // Now it's safe to really close the window
  155.   CloseWindow(arg_poWindow);
  156. } // CloseWindowSafely()
  157. /*E*/
  158. char getShortCut(char *arg_sString)
  159. /*S*/
  160. {
  161.   TRACE("Entry");
  162.   char cShortCut = '\0';
  163.  
  164.   // wenn string gefunden
  165.   if (arg_sString)
  166.   {
  167.     int iLen = strlen(arg_sString);
  168.     for (int i=0; i<iLen; ++i)
  169.     {
  170.       // wenn underscore gefunden und noch min. ein zeichen danach
  171.       // vorhanden
  172.       if (arg_sString[i] == '_' && (i < iLen-1))
  173.       {
  174.         // shortcut gefunden. Schleife verlassen
  175.         cShortCut = arg_sString[i+1];
  176.         break;
  177.       } // if
  178.     } // for
  179.   } // if
  180.  
  181. return ToLower(cShortCut);
  182. }
  183. /*E*/
  184.  
  185. //******************************************************************//
  186. //******************************************************************//
  187. //
  188. //  BarWindowNodeC
  189. //
  190. //******************************************************************//
  191. //******************************************************************//
  192. ULONG BarWindowNodeC::m_ulNextFreeID = 0;
  193.  
  194. BarWindowNodeC::BarWindowNodeC(BarWindowListC *arg_poBarWindowList,
  195.                                char *arg_sName,
  196.                                char *arg_sButtonName,
  197.                                char *arg_sScreenName,
  198.                                BOOL arg_bCloseGadget)
  199. /*S*/
  200. {
  201.   TRACE("Konstruktor");
  202.   if (!arg_poBarWindowList)
  203.   {
  204.     TRACE("Falscher Parameter!");
  205.     throw;
  206.   } // if
  207.  
  208.   // init the baseclassmembers
  209.   ln_Succ       = NULL;
  210.   ln_Pred       = NULL;
  211.   ln_Type       = NT_USER;
  212.   ln_Pri        = 0;
  213.  
  214.   // now our members
  215.   m_oName              = arg_sName;
  216.   m_oButtonText        = arg_sButtonName;
  217.   m_poLockedScreen     = NULL;
  218.   m_poBarWindow        = NULL;
  219.   m_oScreenName        = arg_sScreenName;
  220.   m_bGadgetsAttached   = FALSE;
  221.   m_bCloseGadget       = arg_bCloseGadget;
  222.   m_poSharedUserPort   = arg_poBarWindowList->getSharedUserPort();
  223.   m_ulBarWindowID      = ++m_ulNextFreeID;
  224.   m_iWidth             = 150;
  225.   m_iHeight            = 100;
  226.   m_iTop               = 100;
  227.   m_iLeft              = 100;
  228.   m_iBorderTop         = 4;
  229.   m_iBorderLeft        = 4;
  230.   m_iBorderBottom      = 4;
  231.   m_iBorderRight       = 4;
  232.   m_iMaxVisibleEntries = 15;
  233.   m_poFirstGadget      = NULL;
  234.   m_poButton           = NULL;
  235.  
  236.   AddTail(arg_poBarWindowList, this);
  237. } // BarWindowNodeC::BarWindowNodeC()
  238. /*E*/
  239. BarWindowNodeC::~BarWindowNodeC()
  240. /*S*/
  241. {
  242.   TRACE("Destruktor");
  243.  
  244.   // delete the window
  245.   if (m_poBarWindow)
  246.   {
  247.     closeBarWindow();
  248.   } // if
  249.  
  250.   // delete the name
  251.   if (ln_Name)
  252.   {
  253.     delete ln_Name;
  254.   } // if
  255.  
  256.   // if the node is in a list
  257.   if (ln_Pred && ln_Succ)
  258.   {
  259.     Remove(this);
  260.   } // if
  261. }
  262. /*E*/
  263. struct Screen *BarWindowNodeC::lockScreen()
  264. /*S*/
  265. {
  266.   TRACE("Entry");
  267.   if (m_poLockedScreen)
  268.   {
  269.     TRACE("Screen already locked!");
  270.     return m_poLockedScreen;
  271.   } //
  272.  
  273.   // lock the wanted screen
  274.   if (m_oScreenName.isEmpty())
  275.   {
  276.     m_poLockedScreen = LockPubScreen(NULL);
  277.   }
  278.   else
  279.   {
  280.     m_poLockedScreen = LockPubScreen(m_oScreenName);
  281.   } // if
  282.  
  283. return m_poLockedScreen;
  284. }
  285. /*E*/
  286. void BarWindowNodeC::unlockScreen()
  287. /*S*/
  288. {
  289.   TRACE("Entry");
  290.   // wenn wir einen public screen gelockt haben.
  291.   if (m_poLockedScreen)
  292.   {
  293.     UnlockPubScreen(NULL, m_poLockedScreen);
  294.     m_poLockedScreen = NULL;
  295.   } // if
  296. }
  297. /*E*/
  298. BOOL BarWindowNodeC::openBarWindow()
  299. /*S*/
  300. {
  301.   TRACE("Entry");
  302.  
  303. BOOL erfolg = FALSE;
  304.   // wenn das Fenster schon offen ist
  305.   if (isOpen())
  306.   {
  307.     TRACE("schon offen");
  308.     // dann nur aktivieren und zurückkehren
  309.     ActivateWindow(m_poBarWindow);
  310.     WindowToFront(m_poBarWindow);
  311.     return TRUE;
  312.   } // if
  313.  
  314.   // Wenn wir eine Bar-Liste haben.
  315.   TRACE("Bars vorhanden");
  316.   lockScreen();
  317.  
  318.   validateWindowSize();
  319.   setBarWindowPos(-1,-1);
  320.   createGadgets();
  321.  
  322.   if (m_poBarWindow = OpenWindowTags(NULL,
  323.         WA_Width, m_iWidth,
  324.         WA_Height, m_iHeight,
  325.         WA_AutoAdjust, TRUE,
  326.         WA_Top, m_iTop,
  327.         WA_Left, m_iLeft,
  328.         WA_PubScreen, m_poLockedScreen,
  329.         WA_Activate, TRUE,
  330.         WA_DragBar, TRUE,
  331.         WA_DepthGadget, TRUE,
  332.         WA_CloseGadget, m_bCloseGadget,
  333.         WA_SizeGadget, FALSE,
  334.         WA_SmartRefresh, TRUE,
  335.         WA_RMBTrap, TRUE,
  336.         WA_IDCMP, NULL,
  337.         WA_Title, (char *) m_oName,
  338.         TAG_DONE))
  339.   {
  340.     TRACE("Fenster ist jetzt offen");
  341.     m_poBarWindow->UserPort = m_poSharedUserPort;
  342.     ModifyIDCMP(m_poBarWindow,   CLOSEWINDOW
  343.                                | REFRESHWINDOW
  344.                                | BUTTONIDCMP
  345.                                | IDCMP_VANILLAKEY
  346.                                | IDCMP_RAWKEY);
  347.     m_poBarWindow->UserData = (char *) this;
  348.     showGadgets();
  349.     erfolg = TRUE;
  350.   } // if
  351. return erfolg;
  352. }
  353. /*E*/
  354. void BarWindowNodeC::closeBarWindow()
  355. /*S*/
  356. {
  357.   TRACE("Entry");
  358.   m_iLeft = m_poBarWindow->LeftEdge;
  359.   m_iTop = m_poBarWindow->TopEdge;
  360.  
  361.   hideGadgets();
  362.   CloseWindowSafely(m_poBarWindow);
  363.   unlockScreen();
  364.   m_poBarWindow = NULL;
  365.  
  366.   freeGadgets();
  367. }
  368. /*E*/
  369. void BarWindowNodeC::setBarWindowTitle(char *arg_sName)
  370. /*S*/
  371. { 
  372.   TRACE("Entry");
  373.   m_oName = arg_sName;
  374.   if (isOpen())
  375.   {      
  376.     SetWindowTitles(m_poBarWindow, arg_sName, (char *) ~0);
  377.   } // if
  378. }
  379. /*E*/
  380. struct Gadget *BarWindowNodeC::createGadgets()
  381. /*S*/
  382. {
  383.   TRACE("Entry");
  384.  
  385.   // if no button needed
  386.   if (!hasButton())
  387.   {
  388.     return NULL;
  389.   } // if
  390.  
  391.   // Rückgabe
  392.   struct Gadget *pGad = NULL;
  393.  
  394.   // parameter-check
  395.   if (!m_poLockedScreen)
  396.   {
  397.     TRACE("Wrong createGadgets()-Parameter!");
  398.     return pGad;
  399.   } // if
  400.  
  401.   VisualInfoC oVI(m_poLockedScreen);
  402.   if (!oVI)
  403.   {
  404.     TRACE("VisualInfo failed");
  405.     return pGad;
  406.   } // if
  407.  
  408.   // für Gadtools erforderlich
  409.   pGad = CreateContext(&m_poFirstGadget);
  410.   if (pGad)
  411.   {
  412.     TRACE("CreateContext ok");
  413.  
  414.     // ermittle die Hoehe der Balken
  415.     int iHeightOfBars = m_oBarList.getHeight(m_poLockedScreen);
  416.  
  417.     TextMeasureC oTeMe(m_poLockedScreen);
  418.     struct NewGadget ng;
  419.     ng.ng_Width      = oTeMe.getTextWidth(m_oButtonText) + 10;
  420.     ng.ng_Height     = oTeMe.getTextHeight() + 6;
  421.     ng.ng_TopEdge    = m_poLockedScreen->WBorTop + m_poLockedScreen->BarHeight + iHeightOfBars + oTeMe.getTextHeight() + m_iBorderTop;
  422.  
  423.     // breite und hoehe des Fensters neu anpassen
  424.     m_iHeight = ng.ng_TopEdge + ng.ng_Height + m_poLockedScreen->WBorBottom+4;
  425.     if (ng.ng_Width > m_iWidth - m_poLockedScreen->WBorLeft - m_poLockedScreen->WBorRight - 20)
  426.     {
  427.       m_iWidth = ng.ng_Width + m_poLockedScreen->WBorLeft + m_poLockedScreen->WBorRight + 20;
  428.     } // if
  429.     ng.ng_LeftEdge   = (m_iWidth-oTeMe.getTextWidth(m_oButtonText) - 10)/2;
  430.     ng.ng_GadgetText = (char *) m_oButtonText;
  431.     ng.ng_TextAttr   = m_poLockedScreen->Font;
  432.     ng.ng_Flags      = PLACETEXT_IN;
  433.     ng.ng_GadgetID   = 42;
  434.     ng.ng_UserData   = NULL;
  435.     ng.ng_VisualInfo = oVI;
  436.     // Das Weiter-Gadget jetzt erstellen
  437.     m_poButton = pGad = CreateGadget(BUTTON_KIND, pGad, &ng,
  438.         GT_Underscore, '_',
  439.         TAG_DONE);
  440.     if (pGad)
  441.     {
  442.       TRACE("Gadgets ok");
  443.     } // if
  444.   } // if
  445. return pGad;
  446. }
  447. /*E*/
  448. void BarWindowNodeC::freeGadgets()
  449. /*S*/
  450. {
  451.   TRACE("Entry");
  452.   // if no button needed
  453.   if (!hasButton())
  454.   {
  455.     return;
  456.   } // if
  457.  
  458.   // wenn das Fenster noch offen ist
  459.   if (m_poBarWindow)
  460.   {
  461.     // die gadget vorher removen
  462.     hideGadgets();
  463.   } // if
  464.  
  465.   // wenn die gadget "befreit" werden müssen
  466.   if (m_poFirstGadget)
  467.   {
  468.     FreeGadgets(m_poFirstGadget);
  469.     m_poFirstGadget = NULL;
  470.     m_poButton = NULL;
  471.   } // if
  472. }
  473. /*E*/
  474. void BarWindowNodeC::clearBarWindow()
  475. /*S*/
  476. {
  477.   TRACE("Entry");
  478.   // wenn Fenster offen
  479.   if (isOpen())
  480.   {
  481.     EraseRect(m_poBarWindow->RPort,
  482.               m_poBarWindow->BorderLeft,
  483.               m_poBarWindow->BorderTop,
  484.               m_poBarWindow->Width-m_poBarWindow->BorderRight-1,
  485.               m_poBarWindow->Height-m_poBarWindow->BorderBottom-1);
  486.  
  487.   } // if
  488. }
  489. /*E*/
  490. void BarWindowNodeC::hideGadgets()
  491. /*S*/
  492. {
  493.   TRACE("Entry");
  494.  
  495.   // if no button needed
  496.   if (!hasButton())
  497.   {
  498.     return;
  499.   } // if
  500.  
  501.   // validation check
  502.   if (!m_poBarWindow || !m_poFirstGadget)
  503.   {
  504.     TRACE("Falsche Parameter");
  505.     return;
  506.   } // if
  507.  
  508.   if (!m_bGadgetsAttached)
  509.   {
  510.     TRACE("Gadgets garnicht attached");
  511.     return;
  512.   } // if
  513.   RemoveGList(m_poBarWindow, m_poFirstGadget, ~0);
  514.  
  515.   m_bGadgetsAttached = FALSE;
  516. }
  517. /*E*/
  518. void BarWindowNodeC::showGadgets()
  519. /*S*/
  520. {
  521.   TRACE("Entry");
  522.  
  523.   clearBarWindow();
  524.   m_oBarList.drawBars(this,
  525.                       m_poLockedScreen->WBorLeft + m_iBorderLeft,
  526.                       m_poLockedScreen->WBorTop + m_poLockedScreen->BarHeight + m_iBorderTop);
  527.  
  528.   // if no button needed
  529.   if (m_oButtonText.isEmpty())
  530.   {
  531.     return;
  532.   } // if
  533.  
  534.   // validation check
  535.   if (!m_poBarWindow || !m_poFirstGadget)
  536.   {
  537.     TRACE("Falsche Parameter");
  538.     return;
  539.   } // if
  540.  
  541.   // wenn das Fenster bereits Gadgets hat
  542.   if (m_bGadgetsAttached)
  543.   {
  544.     TRACE("Gadgets bereits vorhanden");
  545.     return;
  546.   } // if
  547.  
  548.   AddGList(m_poBarWindow, m_poFirstGadget, -1, -1, NULL);
  549.   RefreshGList(m_poFirstGadget, m_poBarWindow, NULL, -1);
  550.   GT_RefreshWindow(m_poBarWindow, NULL);
  551.  
  552.   VisualInfoC oVI(m_poBarWindow);
  553.   if (oVI.isOk())
  554.   {
  555.     TRACE("Visualinfo ok");
  556.     //int width = m_poBarWindow->Width - m_poBarWindow->WScreen->WBorLeft - m_poBarWindow->WScreen->WBorLeft - 8;
  557.     int width = m_poBarWindow->Width - m_poLockedScreen->WBorLeft - m_poLockedScreen->WBorRight - m_iBorderLeft - m_iBorderRight;
  558.     int top = m_poLockedScreen->WBorTop + m_poLockedScreen->BarHeight + m_iBorderTop;
  559.         top += m_oBarList.getSize() * (m_poBarWindow->WScreen->Font->ta_YSize + 6);
  560.  
  561.     DrawBevelBox( m_poBarWindow->RPort,
  562.                   m_poLockedScreen->WBorLeft + m_iBorderLeft,
  563.                   top + 6,
  564.                   width,
  565.                   2,
  566.                   GT_VisualInfo, (APTR) oVI,
  567.                   GTBB_Recessed, TRUE,
  568.                   TAG_DONE );
  569.   } // if
  570.  
  571.   m_bGadgetsAttached = TRUE;
  572. }
  573. /*E*/
  574. void BarWindowNodeC::validateWindowSize()
  575. /*S*/
  576. { 
  577.   TRACE("Entry");
  578.   setBarWindowWidth(m_iWidth);
  579. }
  580. /*E*/
  581. void BarWindowNodeC::setBarWindowWidth(ULONG arg_ulWidth)
  582. /*S*/
  583. {
  584.   TRACE("Entry");
  585.   // wenn das fenster offen ist
  586.   if (isOpen())
  587.   {
  588.     hideGadgets();
  589.     int iBarTitleWidth = m_oBarList.getBarTitleWidth(m_poLockedScreen)
  590.                        + m_poLockedScreen->WBorLeft
  591.                        + m_poLockedScreen->WBorRight
  592.                        + m_iBorderLeft
  593.                        + m_iBorderRight;
  594.     m_iWidth = SIFC_MAX(arg_ulWidth, 50 + iBarTitleWidth);
  595.     m_oBarList.setBarWidth(m_iWidth - iBarTitleWidth);
  596.     TextMeasureC oTeMe(m_poLockedScreen);
  597.     int iHeightOfBars = m_oBarList.getHeight(m_poLockedScreen);
  598.     if (m_poButton)
  599.     {
  600.       m_poButton->LeftEdge = (m_iWidth-oTeMe.getTextWidth(m_oButtonText) - 10)/2;
  601.       m_poButton->TopEdge  = m_poLockedScreen->WBorTop + m_poLockedScreen->BarHeight + iHeightOfBars + oTeMe.getTextHeight() + m_iBorderTop;
  602.       m_iHeight = m_poButton->TopEdge + m_poButton->Height + m_poLockedScreen->WBorBottom+4;
  603.     }
  604.     else
  605.     {
  606.       m_iHeight = m_poLockedScreen->WBorTop + m_poLockedScreen->BarHeight + iHeightOfBars + m_poLockedScreen->WBorBottom+7;
  607.     } // if
  608.  
  609.     ChangeWindowBox(m_poBarWindow,
  610.                     m_poBarWindow->LeftEdge,
  611.                     m_poBarWindow->TopEdge,
  612.                     m_iWidth,
  613.                     m_iHeight);
  614.     Delay(5);
  615.     showGadgets();
  616.   }
  617.   else
  618.   {
  619.     m_iWidth = arg_ulWidth;
  620.     if (m_poLockedScreen)
  621.     {
  622.       int iBarTitleWidth = m_oBarList.getBarTitleWidth(m_poLockedScreen)
  623.                          + m_poLockedScreen->WBorLeft
  624.                          + m_poLockedScreen->WBorRight
  625.                          + m_iBorderLeft
  626.                          + m_iBorderRight;
  627.       m_iWidth = SIFC_MAX(arg_ulWidth, 50 + iBarTitleWidth);
  628.       m_oBarList.setBarWidth(m_iWidth - iBarTitleWidth);
  629.       TextMeasureC oTeMe(m_poLockedScreen);
  630.       int iHeightOfBars = m_oBarList.getHeight(m_poLockedScreen);
  631.       if (m_poButton)
  632.       {
  633.         m_poButton->LeftEdge = (m_iWidth-oTeMe.getTextWidth(m_oButtonText) - 10)/2;
  634.         m_poButton->TopEdge  = m_poLockedScreen->WBorTop + m_poLockedScreen->BarHeight + iHeightOfBars + oTeMe.getTextHeight() + m_iBorderTop;
  635.       }
  636.       else
  637.       {
  638.         m_iHeight = m_poLockedScreen->WBorTop + m_poLockedScreen->BarHeight + iHeightOfBars + m_poLockedScreen->WBorBottom+7;
  639.       } // if
  640.     } // if
  641.   } // if
  642. }
  643. /*E*/
  644. void BarWindowNodeC::setBarWindowPos(int arg_iPosX, int arg_iPosY)
  645. /*S*/
  646. {
  647.   TRACE("Entry");
  648.   if (!m_poLockedScreen)
  649.   {
  650.     return;
  651.   } // if
  652.  
  653.   switch (arg_iPosX)
  654.   {
  655.     case -1:
  656.       m_iLeft = (m_poLockedScreen->Width - m_iWidth)/2;
  657.       break;
  658.     case -2:
  659.       break;
  660.     default:
  661.       m_iLeft = arg_iPosX;
  662.       break;
  663.   } // switch
  664.  
  665.   switch (arg_iPosY)
  666.   {
  667.     case -1:
  668.       m_iTop = (m_poLockedScreen->Height - m_iHeight)/2;
  669.       break;
  670.     case -2:
  671.       break;
  672.     default:
  673.       m_iTop = arg_iPosY;
  674.       break;
  675.   } // switch
  676.  
  677.   if (isOpen())
  678.   {
  679.     ChangeWindowBox(m_poBarWindow,
  680.                     m_iLeft,
  681.                     m_iTop,
  682.                     m_poBarWindow->Width,
  683.                     m_poBarWindow->Height);
  684.   } // if
  685. }
  686. /*E*/
  687. void BarWindowNodeC::refreshBars()
  688. /*S*/
  689. {
  690.   TRACE("Entry");
  691.   if (!isOpen())
  692.   {
  693.     return;
  694.   } // if
  695.  
  696.   m_oBarList.fillBars(this,
  697.                       m_poLockedScreen->WBorLeft + m_iBorderLeft,
  698.                       m_poLockedScreen->WBorTop + m_poLockedScreen->BarHeight + m_iBorderTop);
  699. }
  700. /*E*/
  701. BarNodeC *BarWindowNodeC::addBar(char *arg_sName, ULONG arg_ulMaxValue)
  702. /*S*/
  703. {
  704.   TRACE("Entry");
  705.   BarNodeC *poNode = m_oBarList.addBar(arg_sName, arg_ulMaxValue);
  706.   validateWindowSize();
  707. return poNode;
  708. }
  709. /*E*/
  710. void BarWindowNodeC::removeBar(ULONG arg_ulBarID)
  711. /*S*/
  712. {
  713.   TRACE("Entry");
  714.   m_oBarList.removeBar(arg_ulBarID);
  715.   validateWindowSize();
  716. }
  717. /*E*/
  718. BOOL BarWindowNodeC::testOKButton()
  719. /*S*/
  720. { 
  721.   TRACE("Entry");
  722.   // if no valid window-pointer
  723.   if (!isOpen())
  724.   {
  725.     return FALSE;
  726.   } // if
  727.  
  728.   BOOL bOk = FALSE;
  729.   // we forbid here to keep out of race conditions with Intuition
  730.   Forbid();
  731.  
  732.   // send back any messages for this window  that have not yet been processed
  733.   struct IntuiMessage *poMsg = (struct IntuiMessage *)m_poBarWindow->UserPort->mp_MsgList.lh_Head;
  734.  
  735.   struct Node *succ;
  736.   while (succ = poMsg->ExecMessage.mn_Node.ln_Succ)
  737.   {
  738.     if (poMsg->IDCMPWindow == m_poBarWindow)
  739.     {
  740.       // Intuition is about to free this message.
  741.       // Make sure that we have politely sent it back.
  742.       Remove((struct Node *) poMsg);
  743.  
  744.       ULONG ulClass = ((struct IntuiMessage *) poMsg)->Class;
  745.       switch (ulClass)
  746.       {
  747.         case IDCMP_GADGETUP:
  748.         case IDCMP_CLOSEWINDOW:
  749.           bOk = TRUE;
  750.           break;
  751.         case IDCMP_VANILLAKEY:
  752.           char cKey = (char) ((struct IntuiMessage *) poMsg)->Code;
  753.           if ((cKey == 27) || (ToLower(cKey) == ::getShortCut(m_oButtonText)))
  754.           {
  755.             bOk = TRUE;
  756.           } // if
  757.           break;
  758.       } // switch
  759.  
  760.       ReplyMsg((struct Message *) poMsg);
  761.     } // if
  762.     poMsg = (struct IntuiMessage *) succ;
  763.   } // while
  764.  
  765.   // turn multitasking back on
  766.   Permit();
  767.  
  768. return bOk;
  769. }
  770. /*E*/
  771. BarWindowNodeC *BarWindowNodeC::getNext(void)
  772. /*S*/
  773. {
  774.   TRACE("getNext()");
  775.   if (ln_Succ && ln_Succ->ln_Succ)
  776.   {
  777.     return (BarWindowNodeC *) ln_Succ;
  778.   } // if
  779.  
  780. return NULL;
  781. }
  782. /*E*/
  783. BarWindowNodeC *BarWindowNodeC::getPrev(void)
  784. /*S*/
  785. {
  786.   TRACE("getPrev()");
  787.   if (ln_Pred && ln_Pred->ln_Pred)
  788.   {
  789.     return (BarWindowNodeC *) ln_Pred;
  790.   } // if
  791.  
  792. return NULL;
  793. }
  794. /*E*/
  795.  
  796. //******************************************************************//
  797. //******************************************************************//
  798. //
  799. //  BarWindowListC
  800. //
  801. //******************************************************************//
  802. //******************************************************************//
  803. BarWindowListC::BarWindowListC()
  804. /*S*/
  805. {
  806.   TRACE("Konstruktor");
  807.   NewList(this);
  808.   m_poSharedUserPort = CreateMsgPort();
  809. } // BarWindowListC::BarWindowListC()
  810. /*E*/
  811. BarWindowListC::~BarWindowListC()
  812. /*S*/
  813. {
  814.   TRACE("Destruktor");
  815.   removeAll();
  816.  
  817.   // delete the port created in the constructor
  818.   if (m_poSharedUserPort)
  819.   {  
  820.     DeleteMsgPort(m_poSharedUserPort);
  821.   } // if
  822. } // BarWindowListC::~FLXWacthListC()
  823. /*E*/
  824. void BarWindowListC::removeAll()
  825. /*S*/
  826. {
  827.   TRACE("Entry");
  828.   // wenn die Liste nicht leer ist
  829.   if (!IsListEmpty(this))
  830.   {
  831.     BarWindowNodeC *poNode;
  832.     while (poNode = (BarWindowNodeC *) RemHead(this))
  833.     {
  834.       // Vorgaenger und Nachfolger auf null setzen
  835.       // weil mit RemHead schon removed und der Destruktor
  836.       // das bei nicht nulligen nodes nochmal machen wuerde.
  837.       poNode->ln_Succ = NULL;
  838.       poNode->ln_Pred = NULL;
  839.       delete poNode;
  840.     } // while
  841.   } // if
  842.   NewList(this);
  843. }
  844. /*E*/
  845. void BarWindowListC::removeBarWindow(ULONG arg_ulBarWindowID)
  846. /*S*/
  847. { 
  848.   TRACE("Entry");
  849.   // just find the node an delete it
  850.   BarWindowNodeC *poNode = findBarWindowNode(arg_ulBarWindowID);
  851.   if (poNode)
  852.   {
  853.     delete poNode;
  854.   } // if
  855. }
  856. /*E*/
  857. BarWindowNodeC *BarWindowListC::addBarWindow(char *arg_sName, char *arg_sButtonName, char *arg_sScreenName, BOOL arg_bCloseGadget)
  858. /*S*/
  859. {
  860.   TRACE("Entry");
  861.  
  862.   // neuen Balken erzeugen
  863.   BarWindowNodeC *poNode = new BarWindowNodeC(this, arg_sName, arg_sButtonName, arg_sScreenName, arg_bCloseGadget);
  864.   if (!poNode)
  865.   {
  866.     TRACE("Kein Speicher");
  867.     return FALSE;
  868.   } // if
  869.  
  870. return poNode;
  871. }
  872. /*E*/
  873. BarWindowNodeC *BarWindowListC::findBarWindowNode(ULONG arg_ulBarWindowID)
  874. /*S*/
  875. {
  876.   TRACE("Entry");
  877.   BarWindowNodeC *pNode = NULL;
  878.  
  879.   // wenn die Balkenliste nicht leer ist
  880.   if (!IsListEmpty(this))
  881.   {
  882.     pNode = (BarWindowNodeC *) lh_Head;
  883.     do
  884.     {
  885.       if (pNode->m_ulBarWindowID == arg_ulBarWindowID)
  886.       {
  887.         return pNode;
  888.       } // if
  889.     } while (pNode = pNode->getNext());
  890.   } // if
  891.  
  892. return pNode;
  893. }
  894. /*E*/
  895. int BarWindowListC::indexOf(BarWindowNodeC *arg_pNode)
  896. /*S*/
  897. {
  898.   TRACE("Entry");
  899.  
  900.   // wenn die Balkenliste nicht leer ist
  901.   if (arg_pNode && !IsListEmpty(this))
  902.   {
  903.     int iIndex = 0;
  904.  
  905.     // hole 1. eintrag
  906.     BarWindowNodeC *pNode = (BarWindowNodeC *) lh_Head;
  907.     do
  908.     {
  909.       // wenn gefunden
  910.       if (pNode==arg_pNode)
  911.       {
  912.         return iIndex;
  913.       } // if
  914.  
  915.       iIndex++;
  916.     } while (pNode = pNode->getNext());
  917.   } // if
  918.  
  919. return -1;
  920. }
  921. /*E*/
  922. BarWindowNodeC *BarWindowListC::operator[](int arg_iIndex)
  923. /*S*/
  924. {
  925.   TRACE("ENTRY");
  926.  
  927.   BarWindowNodeC *pNode = NULL;
  928.  
  929.   // wenn die Balken nicht leer ist
  930.   if (!IsListEmpty(this))
  931.   {
  932.     int index = 0;
  933.  
  934.     // hole 1. eintrag
  935.     pNode = (BarWindowNodeC *) lh_Head;
  936.     do
  937.     {
  938.       // wenn i.ten eintrag erreicht
  939.       if (index == arg_iIndex)
  940.       {
  941.         return pNode;
  942.       } // if
  943.  
  944.       index++;
  945.     } while (pNode = pNode->getNext());
  946.   } // if
  947.  
  948. return pNode;
  949. }
  950. /*E*/
  951. int BarWindowListC::getSize(void)
  952. /*S*/
  953. {
  954.   TRACE("Entry");
  955.   int iSize = 0;
  956.  
  957.   // wenn die Liste nicht leer ist
  958.   if (!IsListEmpty(this))
  959.   {
  960.     // hole 1. Eintrag
  961.     BarWindowNodeC *pNode = (BarWindowNodeC *) lh_Head;
  962.     for (iSize=1; pNode = pNode->getNext(); iSize++);
  963.   } // if
  964.  
  965. return iSize;
  966. }
  967. /*E*/
  968.  
  969.